home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / compiler / symbols.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  456 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from compiler import ast
  5. from compiler.consts import SC_LOCAL, SC_GLOBAL, SC_FREE, SC_CELL, SC_UNKNOWN
  6. from compiler.misc import mangle
  7. import types
  8. import sys
  9. MANGLE_LEN = 256
  10.  
  11. class Scope:
  12.     
  13.     def __init__(self, name, module, klass = None):
  14.         self.name = name
  15.         self.module = module
  16.         self.defs = { }
  17.         self.uses = { }
  18.         self.globals = { }
  19.         self.params = { }
  20.         self.frees = { }
  21.         self.cells = { }
  22.         self.children = []
  23.         self.nested = None
  24.         self.generator = None
  25.         self.klass = None
  26.         if klass is not None:
  27.             for i in range(len(klass)):
  28.                 if klass[i] != '_':
  29.                     self.klass = klass[i:]
  30.                     break
  31.                     continue
  32.             
  33.         
  34.  
  35.     
  36.     def __repr__(self):
  37.         return '<%s: %s>' % (self.__class__.__name__, self.name)
  38.  
  39.     
  40.     def mangle(self, name):
  41.         if self.klass is None:
  42.             return name
  43.         
  44.         return mangle(name, self.klass)
  45.  
  46.     
  47.     def add_def(self, name):
  48.         self.defs[self.mangle(name)] = 1
  49.  
  50.     
  51.     def add_use(self, name):
  52.         self.uses[self.mangle(name)] = 1
  53.  
  54.     
  55.     def add_global(self, name):
  56.         name = self.mangle(name)
  57.         if self.uses.has_key(name) or self.defs.has_key(name):
  58.             pass
  59.         
  60.         if self.params.has_key(name):
  61.             raise SyntaxError, '%s in %s is global and parameter' % (name, self.name)
  62.         
  63.         self.globals[name] = 1
  64.         self.module.add_def(name)
  65.  
  66.     
  67.     def add_param(self, name):
  68.         name = self.mangle(name)
  69.         self.defs[name] = 1
  70.         self.params[name] = 1
  71.  
  72.     
  73.     def get_names(self):
  74.         d = { }
  75.         d.update(self.defs)
  76.         d.update(self.uses)
  77.         d.update(self.globals)
  78.         return d.keys()
  79.  
  80.     
  81.     def add_child(self, child):
  82.         self.children.append(child)
  83.  
  84.     
  85.     def get_children(self):
  86.         return self.children
  87.  
  88.     
  89.     def DEBUG(self):
  90.         print >>sys.stderr, self.name,
  91.         if not self.nested or 'nested':
  92.             pass
  93.         print >>sys.stderr, ''
  94.         print >>sys.stderr, '\tglobals: ', self.globals
  95.         print >>sys.stderr, '\tcells: ', self.cells
  96.         print >>sys.stderr, '\tdefs: ', self.defs
  97.         print >>sys.stderr, '\tuses: ', self.uses
  98.         print >>sys.stderr, '\tfrees:', self.frees
  99.  
  100.     
  101.     def check_name(self, name):
  102.         if self.globals.has_key(name):
  103.             return SC_GLOBAL
  104.         
  105.         if self.cells.has_key(name):
  106.             return SC_CELL
  107.         
  108.         if self.defs.has_key(name):
  109.             return SC_LOCAL
  110.         
  111.         if self.nested:
  112.             if self.frees.has_key(name) or self.uses.has_key(name):
  113.                 return SC_FREE
  114.             
  115.         if self.nested:
  116.             return SC_UNKNOWN
  117.         else:
  118.             return SC_GLOBAL
  119.  
  120.     
  121.     def get_free_vars(self):
  122.         if not self.nested:
  123.             return ()
  124.         
  125.         free = { }
  126.         free.update(self.frees)
  127.         for name in self.uses.keys():
  128.             if not self.defs.has_key(name) or self.globals.has_key(name):
  129.                 free[name] = 1
  130.                 continue
  131.         
  132.         return free.keys()
  133.  
  134.     
  135.     def handle_children(self):
  136.         for child in self.children:
  137.             frees = child.get_free_vars()
  138.             globals = self.add_frees(frees)
  139.             for name in globals:
  140.                 child.force_global(name)
  141.             
  142.         
  143.  
  144.     
  145.     def force_global(self, name):
  146.         self.globals[name] = 1
  147.         if self.frees.has_key(name):
  148.             del self.frees[name]
  149.         
  150.         for child in self.children:
  151.             if child.check_name(name) == SC_FREE:
  152.                 child.force_global(name)
  153.                 continue
  154.         
  155.  
  156.     
  157.     def add_frees(self, names):
  158.         child_globals = []
  159.         for name in names:
  160.             sc = self.check_name(name)
  161.             if self.nested:
  162.                 if sc == SC_UNKNOWN and sc == SC_FREE or isinstance(self, ClassScope):
  163.                     self.frees[name] = 1
  164.                 elif sc == SC_GLOBAL:
  165.                     child_globals.append(name)
  166.                 elif isinstance(self, FunctionScope) and sc == SC_LOCAL:
  167.                     self.cells[name] = 1
  168.                 elif sc != SC_CELL:
  169.                     child_globals.append(name)
  170.                 
  171.             sc == SC_LOCAL
  172.             if sc == SC_LOCAL:
  173.                 self.cells[name] = 1
  174.                 continue
  175.             if sc != SC_CELL:
  176.                 child_globals.append(name)
  177.                 continue
  178.         
  179.         return child_globals
  180.  
  181.     
  182.     def get_cell_vars(self):
  183.         return self.cells.keys()
  184.  
  185.  
  186.  
  187. class ModuleScope(Scope):
  188.     __super_init = Scope.__init__
  189.     
  190.     def __init__(self):
  191.         self._ModuleScope__super_init('global', self)
  192.  
  193.  
  194.  
  195. class FunctionScope(Scope):
  196.     pass
  197.  
  198.  
  199. class GenExprScope(Scope):
  200.     __super_init = Scope.__init__
  201.     __counter = 1
  202.     
  203.     def __init__(self, module, klass = None):
  204.         i = self._GenExprScope__counter
  205.         self._GenExprScope__counter += 1
  206.         self._GenExprScope__super_init('generator expression<%d>' % i, module, klass)
  207.         self.add_param('.0')
  208.  
  209.     
  210.     def get_names(self):
  211.         keys = Scope.get_names(self)
  212.         return keys
  213.  
  214.  
  215.  
  216. class LambdaScope(FunctionScope):
  217.     __super_init = Scope.__init__
  218.     __counter = 1
  219.     
  220.     def __init__(self, module, klass = None):
  221.         i = self._LambdaScope__counter
  222.         self._LambdaScope__counter += 1
  223.         self._LambdaScope__super_init('lambda.%d' % i, module, klass)
  224.  
  225.  
  226.  
  227. class ClassScope(Scope):
  228.     __super_init = Scope.__init__
  229.     
  230.     def __init__(self, name, module):
  231.         self._ClassScope__super_init(name, module, name)
  232.  
  233.  
  234.  
  235. class SymbolVisitor:
  236.     
  237.     def __init__(self):
  238.         self.scopes = { }
  239.         self.klass = None
  240.  
  241.     
  242.     def visitModule(self, node):
  243.         scope = self.module = self.scopes[node] = ModuleScope()
  244.         self.visit(node.node, scope)
  245.  
  246.     visitExpression = visitModule
  247.     
  248.     def visitFunction(self, node, parent):
  249.         if node.decorators:
  250.             self.visit(node.decorators, parent)
  251.         
  252.         parent.add_def(node.name)
  253.         for n in node.defaults:
  254.             self.visit(n, parent)
  255.         
  256.         scope = FunctionScope(node.name, self.module, self.klass)
  257.         if parent.nested or isinstance(parent, FunctionScope):
  258.             scope.nested = 1
  259.         
  260.         self.scopes[node] = scope
  261.         self._do_args(scope, node.argnames)
  262.         self.visit(node.code, scope)
  263.         self.handle_free_vars(scope, parent)
  264.  
  265.     
  266.     def visitGenExpr(self, node, parent):
  267.         scope = GenExprScope(self.module, self.klass)
  268.         if parent.nested and isinstance(parent, FunctionScope) or isinstance(parent, GenExprScope):
  269.             scope.nested = 1
  270.         
  271.         self.scopes[node] = scope
  272.         self.visit(node.code, scope)
  273.         self.handle_free_vars(scope, parent)
  274.  
  275.     
  276.     def visitGenExprInner(self, node, scope):
  277.         for genfor in node.quals:
  278.             self.visit(genfor, scope)
  279.         
  280.         self.visit(node.expr, scope)
  281.  
  282.     
  283.     def visitGenExprFor(self, node, scope):
  284.         self.visit(node.assign, scope, 1)
  285.         self.visit(node.iter, scope)
  286.         for if_ in node.ifs:
  287.             self.visit(if_, scope)
  288.         
  289.  
  290.     
  291.     def visitGenExprIf(self, node, scope):
  292.         self.visit(node.test, scope)
  293.  
  294.     
  295.     def visitLambda(self, node, parent, assign = 0):
  296.         for n in node.defaults:
  297.             self.visit(n, parent)
  298.         
  299.         scope = LambdaScope(self.module, self.klass)
  300.         if parent.nested or isinstance(parent, FunctionScope):
  301.             scope.nested = 1
  302.         
  303.         self.scopes[node] = scope
  304.         self._do_args(scope, node.argnames)
  305.         self.visit(node.code, scope)
  306.         self.handle_free_vars(scope, parent)
  307.  
  308.     
  309.     def _do_args(self, scope, args):
  310.         for name in args:
  311.             if type(name) == types.TupleType:
  312.                 self._do_args(scope, name)
  313.                 continue
  314.             scope.add_param(name)
  315.         
  316.  
  317.     
  318.     def handle_free_vars(self, scope, parent):
  319.         parent.add_child(scope)
  320.         scope.handle_children()
  321.  
  322.     
  323.     def visitClass(self, node, parent):
  324.         parent.add_def(node.name)
  325.         for n in node.bases:
  326.             self.visit(n, parent)
  327.         
  328.         scope = ClassScope(node.name, self.module)
  329.         if parent.nested or isinstance(parent, FunctionScope):
  330.             scope.nested = 1
  331.         
  332.         if node.doc is not None:
  333.             scope.add_def('__doc__')
  334.         
  335.         scope.add_def('__module__')
  336.         self.scopes[node] = scope
  337.         prev = self.klass
  338.         self.klass = node.name
  339.         self.visit(node.code, scope)
  340.         self.klass = prev
  341.         self.handle_free_vars(scope, parent)
  342.  
  343.     
  344.     def visitName(self, node, scope, assign = 0):
  345.         if assign:
  346.             scope.add_def(node.name)
  347.         else:
  348.             scope.add_use(node.name)
  349.  
  350.     
  351.     def visitFor(self, node, scope):
  352.         self.visit(node.assign, scope, 1)
  353.         self.visit(node.list, scope)
  354.         self.visit(node.body, scope)
  355.         if node.else_:
  356.             self.visit(node.else_, scope)
  357.         
  358.  
  359.     
  360.     def visitFrom(self, node, scope):
  361.         for name, asname in node.names:
  362.             if name == '*':
  363.                 continue
  364.             
  365.             if not asname:
  366.                 pass
  367.             scope.add_def(name)
  368.         
  369.  
  370.     
  371.     def visitImport(self, node, scope):
  372.         for name, asname in node.names:
  373.             i = name.find('.')
  374.             if i > -1:
  375.                 name = name[:i]
  376.             
  377.             if not asname:
  378.                 pass
  379.             scope.add_def(name)
  380.         
  381.  
  382.     
  383.     def visitGlobal(self, node, scope):
  384.         for name in node.names:
  385.             scope.add_global(name)
  386.         
  387.  
  388.     
  389.     def visitAssign(self, node, scope):
  390.         for n in node.nodes:
  391.             self.visit(n, scope, 1)
  392.         
  393.         self.visit(node.expr, scope)
  394.  
  395.     
  396.     def visitAssName(self, node, scope, assign = 1):
  397.         scope.add_def(node.name)
  398.  
  399.     
  400.     def visitAssAttr(self, node, scope, assign = 0):
  401.         self.visit(node.expr, scope, 0)
  402.  
  403.     
  404.     def visitSubscript(self, node, scope, assign = 0):
  405.         self.visit(node.expr, scope, 0)
  406.         for n in node.subs:
  407.             self.visit(n, scope, 0)
  408.         
  409.  
  410.     
  411.     def visitSlice(self, node, scope, assign = 0):
  412.         self.visit(node.expr, scope, 0)
  413.         if node.lower:
  414.             self.visit(node.lower, scope, 0)
  415.         
  416.         if node.upper:
  417.             self.visit(node.upper, scope, 0)
  418.         
  419.  
  420.     
  421.     def visitAugAssign(self, node, scope):
  422.         self.visit(node.node, scope)
  423.         if isinstance(node.node, ast.Name):
  424.             self.visit(node.node, scope, 1)
  425.         
  426.         self.visit(node.expr, scope)
  427.  
  428.     _const_types = (types.StringType, types.IntType, types.FloatType)
  429.     
  430.     def visitIf(self, node, scope):
  431.         for test, body in node.tests:
  432.             if isinstance(test, ast.Const):
  433.                 if type(test.value) in self._const_types:
  434.                     if not test.value:
  435.                         continue
  436.                     
  437.                 
  438.             
  439.             self.visit(test, scope)
  440.             self.visit(body, scope)
  441.         
  442.         if node.else_:
  443.             self.visit(node.else_, scope)
  444.         
  445.  
  446.     
  447.     def visitYield(self, node, scope):
  448.         scope.generator = 1
  449.         self.visit(node.value, scope)
  450.  
  451.  
  452.  
  453. def list_eq(l1, l2):
  454.     return sorted(l1) == sorted(l2)
  455.  
  456.